#!/bin/bash
# First, let's understand the overall structure
echo "=== Project Structure ==="
fd -t f -e rs . | head -20

echo -e "\n=== Main CLI file size and structure ==="
wc -l src/main.rs
rg -n "^(pub )?fn " src/main.rs | head -30

echo -e "\n=== Check for remaining parse functions in CLI ==="
rg -n "fn parse_" src/main.rs

echo -e "\n=== Check for type definitions in CLI that might duplicate crate types ==="
rg -n "^(pub )?struct " src/main.rs

echo -e "\n=== Check for CLI-specific constants that might be duplicated ==="
rg -n "^(pub )?const " src/main.rs

#!/bin/bash
# Check the crate's public API to understand what's available
echo "=== Crate lib.rs structure ==="
cat src/lib.rs

echo -e "\n=== Parser module structure ==="
fd "parser" -t f -e rs

echo -e "\n=== Check what's in parser modules ==="
ls -la src/parser/ 2>/dev/null || echo "No parser directory in src"

echo -e "\n=== Types module ==="
cat src/types.rs 2>/dev/null | head -100

#!/bin/bash
# Look for CLI-specific utility functions
echo "=== All functions in main.rs ==="
ast-grep --pattern 'fn $FUNC($$$) { $$$ }'

echo -e "\n=== Check for duplicated helper functions ==="
rg -n "fn (read_|write_|process_|handle_)" src/main.rs

#!/bin/bash
# Check for any remaining encoding-related code in CLI
echo "=== Encoding constants usage in main.rs ==="
rg -n "ENCODING_" src/main.rs | head -30

echo -e "\n=== Check parser module exports ==="
cat src/parser/mod.rs 2>/dev/null || echo "No parser/mod.rs"

echo -e "\n=== Check what parser submodules exist ==="
fd . src/parser -t f -e rs
cat src/parser/frame.rs | head -50

#!/bin/bash
# Look for stream processing and other CLI-specific logic
echo "=== Stream processing functions in main.rs ==="
rg -n "fn.*stream" src/main.rs -A 2

echo -e "\n=== CSV output related functions ==="
rg -n "fn.*(csv|output)" src/main.rs -A 2

echo -e "\n=== File I/O functions ==="
rg -n "fn.*(read|write|file)" src/main.rs -A 2

echo -e "\n=== Check imports in main.rs to see what CLI uses from crate ==="
rg "^use bbl_parser::" src/main.rs

#!/bin/bash
# Check what types exist in the crate vs CLI
echo "=== Types in crate's types.rs ==="
cat src/types.rs

echo -e "\n=== Check what's in crate's conversion module ==="
cat src/conversion.rs | head -100

echo -e "\n=== Check parser/header module ==="
cat src/parser/header.rs | head -80

#!/bin/bash
# Look for specific functions that might be duplicated or should be in crate
echo "=== Check parse_headers_from_text in main.rs ==="
rg -n "fn parse_headers_from_text" src/main.rs -A 10

echo -e "\n=== Check convert_vbat_to_volts in main.rs ==="
rg -n "fn convert_vbat_to_volts" src/main.rs -A 20

echo -e "\n=== Check if convert_vbat_to_volts is in conversion module ==="
rg -n "convert_vbat_to_volts" src/conversion.rs

echo -e "\n=== Check parse_signed_data and parse_numeric_data ==="
rg -n "fn parse_(signed|numeric)_data" src/main.rs -A 5

#!/bin/bash
# Check for other analysis utilities
echo "=== has_minimal_gyro_activity function ==="
rg -n "fn has_minimal_gyro_activity" src/main.rs -A 30

echo -e "\n=== calculate_variance function ==="
rg -n "fn calculate_variance" src/main.rs -A 10

echo -e "\n=== Check for similar functions in crate ==="
rg -n "variance|gyro" src/lib.rs src/conversion.rs src/parser/*.rs

#!/bin/bash
# Check what's actually public in the crate and what CLI is using
echo "=== Check what's exported from crate ==="
rg "^pub (struct|enum|fn|type)" src/lib.rs src/types.rs src/conversion.rs src/export.rs | head -50

echo -e "\n=== Compare BBLHeader in CLI vs types in crate ==="
rg -n "^struct BBLHeader" src/main.rs -A 20
rg -n "^pub struct.*Header" src/types.rs src/parser/header.rs -A 20

#!/bin/bash
# Check the export functionality
echo "=== What's in export module ==="
cat src/export.rs | head -100

echo -e "\n=== Check crate examples for usage patterns ==="
ls -la examples/
rg "use bbl_parser" examples/*.rs | head -20

#!/bin/bash
# Find where types are defined in the crate
echo "=== Search for BBLHeader definition in crate ==="
rg -n "struct BBLHeader" src/parser/ src/*.rs

echo -e "\n=== Search for DecodedFrame, FrameStats in crate ==="
rg -n "struct (DecodedFrame|FrameStats|BBLLog)" src/parser/ src/*.rs

echo -e "\n=== Check what's actually in parser/main.rs ==="
cat src/parser/main.rs

echo -e "\n=== Check lib.rs for type re-exports ==="
cat src/lib.rs

#!/bin/bash
# Compare what CLI imports vs what it defines locally
echo "=== Full list of struct definitions in main.rs ==="
rg -n "^struct" src/main.rs

echo -e "\n=== What does CLI import from bbl_parser? ==="
rg -n "^use bbl_parser" src/main.rs -A 2

echo -e "\n=== Check for format_* functions in main.rs ==="
rg -n "fn format_(flight_mode|state|failsafe)" src/main.rs

#!/bin/bash
# Check if there's actually a main parsing function in crate
echo "=== Search for parse_bbl_file in crate ==="
rg -n "pub fn parse_bbl_file" src/parser/*.rs

echo -e "\n=== What's exported from parser/main.rs ==="
cat src/parser/main.rs | grep "^pub"

echo -e "\n=== Check the relationship between CLI and crate for BBL parsing ==="
rg -n "fn parse_bbl_file\(" src/main.rs -A 5

#!/bin/bash
# Look at what types the crate examples are using
echo "=== Check examples to see what types they import ==="
cat examples/csv_export.rs

echo -e "\n=== Check multi_export example ==="
cat examples/multi_export.rs | head -80

#!/bin/bash
# Check if there are more duplicated conversion functions
echo "=== All conversion functions in main.rs ==="
rg -n "^fn (convert_|extract_|format_)" src/main.rs

echo -e "\n=== All conversion functions in conversion.rs ==="
rg -n "^pub fn (convert_|extract_|format_)" src/conversion.rs

echo -e "\n=== Check if CLI is using conversion module ==="
rg "use bbl_parser::conversion" src/main.rs -A 3

#!/bin/bash
# Critical: Check if types.rs should exist but is missing
echo "=== Search for types module references ==="
rg "mod types" src/*.rs
rg "crate::types::" src/parser/*.rs | head -10

echo -e "\n=== Check if types were supposed to be in a types.rs file ==="
ls -la src/types.rs 2>&1

echo -e "\n=== Where are the types actually defined that parser/main.rs uses? ==="
rg "pub use.*types" src/lib.rs
rg "pub mod types" src/lib.rs

#!/bin/bash
# Compare CLI export functions with crate export functions
echo "=== Export function signatures in CLI main.rs ==="
rg -n "^fn export_(logs|single|headers|flight|gpx|event)" src/main.rs | head -20

echo -e "\n=== Export function signatures in crate export.rs ==="
rg -n "^pub fn export_" src/export.rs

echo -e "\n=== Check how CLI calls its own export vs crate export ==="
rg "export_logs_to_csv|export_to_csv" src/main.rs | head -10

#!/bin/bash
# Check what BBLLog and related types are actually used in crate
echo "=== Check parser/frame.rs return types ==="
rg "pub fn parse_frames" src/parser/frame.rs -A 10

echo -e "\n=== Check what types are needed by parse_single_log ==="
rg "BBLLog|BBLHeader|FrameStats|DecodedFrame" src/parser/main.rs | head -20

echo -e "\n=== Check if types are defined anywhere else ==="
fd types.rs

#!/bin/bash
# Understand the complete type situation
echo "=== All type definitions across the project ==="
rg "^pub struct (BBL|Frame|Gps|Event)" src/parser/*.rs src/*.rs

echo -e "\n=== Check what parser/mod.rs exports ==="
cat src/parser/mod.rs

#!/bin/bash
# Check for parse_bbl_file duplication
echo "=== CLI parse_bbl_file implementation ==="
rg -n "^fn parse_bbl_file\(" src/main.rs -A 30 | head -50

echo -e "\n=== Does CLI use crate's parse_bbl_file? ==="
rg "bbl_parser::(parse_bbl_file|parse_bbl_bytes)" src/main.rs

#!/bin/bash
# Create GitHub issue for Phase 5 unification
gh issue create \
  --repo nerdCopter/bbl_parser \
  --title "Complete CLI-to-Crate Unification — Phase 5: Types, Main Parser, and Export Functions" \
  --assignee nerdCopter \
  --label "enhancement" \
  --body "## Overview

This issue completes Phase 5 of the CLI-to-Crate unification by addressing critical missing infrastructure and remaining code duplication. Phase 4 (PR #15) successfully unified frame parsers (S/H/E/I). Phase 5 focuses on core types, main parsing functions, and export functionality.

**Critical Issue**: \`src/lib.rs\` declares \`pub mod types;\` but \`src/types.rs\` doesn't exist. All core types (BBLHeader, BBLLog, FrameStats, DecodedFrame, etc.) are defined in CLI's \`src/main.rs\` instead, preventing the crate from being used as a standalone library.

---

## Objectives

### Phase 5a: Create Missing types.rs Module (CRITICAL)
**Problem**: Crate declares \`pub mod types;\` but file doesn't exist. Types used by \`parser/main.rs\`, \`parser/frame.rs\`, \`parser/header.rs\` are all defined in CLI's main.rs.

**Actions**:
1. Create \`src/types.rs\` 
2. Move these type definitions from CLI's \`src/main.rs\` to crate's \`src/types.rs\`:
   - \`BBLHeader\` (with Default impl)
   - \`BBLLog\`
   - \`FrameStats\` (with Default impl)
   - \`DecodedFrame\`
   - \`FrameDefinition\` (currently imported from crate, verify location)
   - \`EventFrame\` (currently imported from crate, verify location)
   - \`GpsCoordinate\`
   - \`GpsHomeCoordinate\`
   - \`FrameHistory\`
3. Update CLI to import these types: \`use bbl_parser::types::{BBLHeader, BBLLog, FrameStats, DecodedFrame, GpsCoordinate, GpsHomeCoordinate, FrameHistory};\`
4. Remove duplicate type definitions from CLI's main.rs
5. Verify all crate parser modules compile and reference correct types

**Validation**:
- \`cargo build --lib\` succeeds
- \`cargo test --lib\` passes
- All examples compile: \`cargo build --examples\`
- CLI still compiles: \`cargo build --bin bbl_parser\`
- Run example: \`cargo run --example csv_export <test.BBL>\`

**Success**: ~150 lines removed from CLI, crate usable as standalone library, all types in single source of truth.

---

### Phase 5b: Remove Duplicate Conversion Functions from CLI
**Problem**: CLI defines \`convert_vbat_to_volts\`, \`extract_firmware_version\`, \`convert_amperage_to_amps\` at lines 2358-2404, duplicating crate's conversion module. CLI already imports other conversion functions but not these.

**Actions**:
1. Update CLI imports to include missing functions:
   \`\`\`rust
   use bbl_parser::conversion::{
       convert_amperage_to_amps,  // ADD
       convert_gps_altitude, 
       convert_gps_coordinate, 
       convert_gps_course, 
       convert_gps_speed,
       convert_vbat_to_volts,  // ADD
       extract_firmware_version,  // ADD
       format_failsafe_phase, 
       format_flight_mode_flags, 
       format_state_flags, 
       generate_gpx_timestamp,
   };
   \`\`\`
2. Delete duplicate functions from CLI's main.rs (lines ~2358-2404)
3. Verify all call sites in CLI still work

**Validation**:
- \`cargo clippy --bin bbl_parser\` passes
- \`cargo test --bin bbl_parser\` passes
- A/B test: parse same BBL file with master vs this branch, CSV outputs identical

**Success**: ~50 lines removed from CLI, single source for conversion functions.

---

### Phase 5c: Migrate CLI to Use Crate's parse_bbl_file
**Problem**: CLI has own \`parse_bbl_file\` function (lines 615-690) that duplicates crate's \`parse_bbl_file_all_logs\`. CLI doesn't use crate's main parser.

**Actions**:
1. Update CLI's \`parse_bbl_file\` to call crate's function:
   \`\`\`rust
   fn parse_bbl_file(
       file_path: &Path,
       debug: bool,
       export_options: &ExportOptions,
   ) -> Result<Vec<BBLLog>> {
       // Convert CLI's ExportOptions to crate's ExportOptions if they differ
       let crate_export_options = bbl_parser::ExportOptions {
           csv: export_options.csv,
           gpx: export_options.gpx,
           event: export_options.event,
           output_dir: export_options.output_dir.clone(),
           force_export: export_options.force_export,
       };
       bbl_parser::parse_bbl_file_all_logs(file_path, crate_export_options, debug)
   }
   \`\`\`
   OR simply replace call sites with \`bbl_parser::parse_bbl_file_all_logs\` directly.
2. Investigate if CLI's \`ExportOptions\` struct differs from crate's - if identical, use crate's version
3. Delete duplicate \`parse_bbl_file\` and \`parse_single_log\` from CLI after migration
4. Update \`parse_bbl_file_streaming\` if it also duplicates crate functionality

**Validation**:
- CLI builds and runs: \`cargo run --bin bbl_parser -- <test.BBL> --csv\`
- Parsing behavior unchanged: A/B compare CSV outputs
- Multi-log files parse correctly
- All CLI flags work: --debug, --csv, --gpx, --event, etc.

**Success**: ~100+ lines removed from CLI, CLI uses crate's parsing infrastructure.

---

### Phase 5d: Migrate CLI to Use Crate's Export Functions
**Problem**: CLI defines \`export_logs_to_csv\`, \`export_single_log_to_csv\`, \`export_headers_to_csv\`, \`export_flight_data_to_csv\`, \`export_gpx_file\`, \`export_event_file\` that duplicate crate's \`export_to_csv\`, \`export_to_gpx\`, \`export_to_event\`.

**Actions**:
1. Update CLI to use crate's export functions directly:
   \`\`\`rust
   // Replace export_logs_to_csv call
   for log in logs {
       bbl_parser::export_to_csv(&log, input_path, &export_options)?;
       if export_options.gpx {
           bbl_parser::export_to_gpx(input_path, log.log_number - 1, &log, &export_options)?;
       }
       if export_options.event {
           bbl_parser::export_to_event(input_path, log.log_number - 1, &log, &export_options)?;
       }
   }
   \`\`\`
2. Verify CLI's \`ExportOptions\` matches crate's or use crate's version
3. Delete duplicate export functions from CLI (lines ~1354-2630)
4. Check if \`should_skip_export\` and \`has_minimal_gyro_activity\` logic needs to be preserved or moved to crate

**Validation**:
- CSV export works: \`cargo run --bin bbl_parser -- <test.BBL> --csv\`
- GPX export works: \`cargo run --bin bbl_parser -- <test.BBL> --gpx\`
- Event export works: \`cargo run --bin bbl_parser -- <test.BBL> --event\`
- Multi-export works: \`--csv --gpx --event\`
- Output files identical to master (MD5 checksums)
- Skip logic still works (minimal gyro activity detection)

**Success**: ~300+ lines removed from CLI, single export implementation.

---

### Phase 5e (Optional): Add Utility Functions to Crate
**Problem**: CLI has utility functions that might be useful in the crate:
- \`has_minimal_gyro_activity\` (line 1278): Detects ground tests vs real flights
- \`calculate_variance\` (line 1342): Statistical helper
- \`parse_signed_data\`, \`parse_numeric_data\` (lines 2341-2350): Header parsing helpers

**Decision Point**: Are these CLI-specific or library-worthy?

**If library-worthy**:
1. Move functions to appropriate crate modules:
   - \`has_minimal_gyro_activity\`, \`calculate_variance\` → new \`src/analysis.rs\` module
   - \`parse_signed_data\`, \`parse_numeric_data\` → \`src/parser/header.rs\`
2. Make functions public and add tests
3. Update CLI to import from crate

**If CLI-specific**: Keep in CLI, no action needed.

---

## Implementation Strategy

### Commit Structure
Use phased commits (5a-5e) for easy rollback:
\`\`\`
git commit -m \"refactor(phase5a): Create types.rs module with core types\"
git commit -m \"refactor(phase5b): Remove duplicate conversion functions from CLI\"
git commit -m \"refactor(phase5c): Migrate CLI to use crate's parse_bbl_file\"
git commit -m \"refactor(phase5d): Migrate CLI to use crate's export functions\"
git commit -m \"refactor(phase5e): Add utility functions to crate (optional)\"
\`\`\`

### Validation After Each Phase
\`\`\`bash
# Build and test
cargo build --all
cargo test --all
cargo clippy --all

# Test CLI functionality
cargo run --bin bbl_parser -- test.BBL --csv --gpx --event --debug

# Test crate examples
cargo run --example csv_export test.BBL
cargo run --example multi_export test.BBL

# A/B comparison (after all phases)
# Master branch
git checkout master
cargo run --bin bbl_parser -- test.BBL --csv
md5sum output_master.csv

# Feature branch
git checkout <feature_branch>
cargo run --bin bbl_parser -- test.BBL --csv
md5sum output_feature.csv

# Outputs should match
diff output_master.csv output_feature.csv
\`\`\`

---

## Success Criteria

- [ ] **Phase 5a**: \`src/types.rs\` exists with all core types, crate compiles independently
- [ ] **Phase 5b**: CLI removes duplicate conversion functions (~50 lines)
- [ ] **Phase 5c**: CLI uses crate's \`parse_bbl_file_all_logs\` (~100+ lines removed)
- [ ] **Phase 5d**: CLI uses crate's export functions (~300+ lines removed)
- [ ] **Phase 5e**: Utility functions in appropriate location
- [ ] All builds pass: \`cargo build --all\`
- [ ] All tests pass: \`cargo test --all\`
- [ ] Clippy clean: \`cargo clippy --all\`
- [ ] CLI functionality unchanged (A/B CSV comparison)
- [ ] Crate usable as standalone library
- [ ] Examples work: \`cargo run --example csv_export test.BBL\`
- [ ] **Net reduction**: ~500-600 lines of code removed from CLI
- [ ] Single source of truth for all major functionality

---

## Rollback Plan

If validation fails at any phase:
\`\`\`bash
# Revert specific phase commit
git revert HEAD

# Or reset to last good commit
git reset --hard <commit_before_phase>

# Cherry-pick successful phases if some failed
git cherry-pick <phase5a_commit>
git cherry-pick <phase5b_commit>
# Skip failed phase, continue with next
\`\`\`

---

## Additional Notes

### Why Phase 5a is Critical
Without \`src/types.rs\`, the crate cannot be used as a library. Current state:
- \`src/lib.rs\` declares: \`pub mod types;\`
- \`src/parser/main.rs\` uses: \`use crate::types::*;\`
- \`src/parser/frame.rs\` uses: \`use crate::types::{...};\`
- But \`src/types.rs\` doesn't exist!

This means the crate doesn't actually compile independently - it only works when built as part of the binary with CLI's types.

### Type Location Investigation Needed
Before Phase 5a, verify where \`FrameDefinition\` and \`EventFrame\` actually live:
\`\`\`bash
rg \"struct FrameDefinition\" src/
rg \"struct EventFrame\" src/
\`\`\`

CLI imports these from crate currently, so they might already be in the right place.

---

## Related Issues
- Closes #13 (continuation of Phase 4)
- Builds on PR #15

## Estimated Impact
- **Lines removed**: ~500-600 from CLI
- **Maintainability**: Single source of truth for types, parsing, exports
- **Library usability**: Crate becomes fully functional standalone library
- **Testing**: Easier to test core functionality in isolation"

#!/bin/bash
# Get the URL of the created issue to provide to user
sleep 2
gh issue list --repo nerdCopter/bbl_parser --limit 1 --state open --json number,title,url --jq '.[0] | "\(.number): \(.title)\n\(.url)"'

Learnt from: nerdCopter
Repo: nerdCopter/bbl_parser PR: 2
File: LICENSE_COMMERCIAL:1-4
Timestamp: 2025-08-29T19:52:05.099Z
Learning: nerdCopter prefers to avoid publishing personal information in license files for privacy and security reasons, as they are an individual maintainer rather than a company.

Learnt from: nerdCopter
Repo: nerdCopter/bbl_parser PR: 2
File: README.md:520-521
Timestamp: 2025-08-29T19:53:41.354Z
Learning: nerdCopter uses AGPL-3.0-or-later licensing for the bbl_parser project with a dual-licensing approach that includes a separate commercial license option.

Learnt from: nerdCopter
Repo: nerdCopter/bbl_parser PR: 2
File: CONTRIBUTING.md:9-14
Timestamp: 2025-08-21T20:25:45.741Z
Learning: nerdCopter prefers to keep CLA language general using "project maintainer" rather than specifying a legal entity name, as they are an individual maintainer without an associated company.

Learnt from: nerdCopter
Repo: nerdCopter/bbl_parser PR: 2
File: LICENSE_COMMERCIAL:0-0
Timestamp: 2025-08-29T20:15:04.624Z
Learning: nerdCopter prefers clear positive indicators (✅) when describing fixes rather than using ❌ symbols which can be confusing when describing what was corrected in a positive context.